import Vue from 'vue'
import req from '@/utils/request'

// post
export function postAction (url, parameter) {
  return req.post(url, {
    data: parameter
  })
}

// post method= {post | put}
export function httpAction (url, parameter, method) {
  return req({
    url: url,
    method: method,
    data: parameter
  })
}

// put
export function putAction (url, parameter) {
  return req.put(url, {
    data: parameter
  })
}

// get
export function getAction (url, parameter) {
  if (parameter) {
    url += '?'
    const params = []
    for (const key in parameter) {
      params.push(key + '=' + parameter[key])
    }
    url += params.join('&')
  }
  return req.get(url)
}

// deleteAction
export function deleteAction (url, parameter) {
  return req.delete(url, {
    params: parameter
  })
}

/**
 * 下载文件 用于excel导出
 * @param url
 * @param parameter
 * @returns {*}
 */
export function downFile (url, parameter) {
  return req({
    url: url,
    params: parameter,
    method: 'get',
    responseType: 'blob'
  })
}

/**
 * 下载文件
 * @param url 文件路径
 * @param fileName 文件名
 * @param parameter
 * @returns {*}
 */
export function downloadFile (url, fileName, parameter) {
  return downFile(url, parameter).then((data) => {
    if (!data || data.size === 0) {
      Vue.prototype.$message.warning('文件下载失败')
      return
    }
    if (typeof window.navigator.msSaveBlob !== 'undefined') {
      window.navigator.msSaveBlob(new Blob([data]), fileName)
    } else {
      const url = window.URL.createObjectURL(new Blob([data]))
      const link = document.createElement('a')
      link.style.display = 'none'
      link.href = url
      link.setAttribute('download', fileName)
      document.body.appendChild(link)
      link.click()
      document.body.removeChild(link) // 下载完成移除元素
      window.URL.revokeObjectURL(url) // 释放掉blob对象
    }
  })
}

/**
 * 文件上传 用于富文本上传图片
 * @param url
 * @param parameter
 * @returns {*}
 */
export function uploadAction (url, parameter) {
  return req({
    url: url,
    data: parameter,
    method: 'post',
    headers: {
      'Content-Type': 'multipart/form-data' // 文件上传
    }
  })
}

/**
 * 获取文件服务访问路径
 * @param avatar
 * @param subStr
 * @returns {*}
 */
export function getFileAccessHttpUrl (avatar, subStr) {
  if (!subStr) subStr = 'http'
  try {
    if (avatar && avatar.startsWith(subStr)) {
      return avatar
    } else {
      if (avatar && avatar.length > 0 && avatar.indexOf('[') === -1) {
        return window._CONFIG.staticDomainURL + '/' + avatar
      }
    }
  } catch (err) {

  }
}
/**
 * 字典 util
 * author: scott
 * date: 20190109
 */

/**
  * 获取字典数组
  * @param dictCode 字典Code
  * @return List<Map>
  */
export async function initDictOptions (dictCode) {
  if (!dictCode) {
    return '字典Code不能为空!'
  }
  // 优先从缓存中读取字典配置
  if (getDictItemsFromCache(dictCode)) {
    const res = {}
    res.result = getDictItemsFromCache(dictCode)
    res.success = true
    return res
  }
  // 获取字典数组
  const res = await ajaxGetDictItems(dictCode)
  return res
}

/**
  * 字典值替换文本通用方法
  * @param dictOptions  字典数组
  * @param text  字典值
  * @return String
  */
export function filterDictText (dictOptions, text) {
  // --update-begin----author:sunjianlei---date:20200323------for: 字典翻译 text 允许逗号分隔 ---
  if (text != null && Array.isArray(dictOptions)) {
    const result = []
    // 允许多个逗号分隔，允许传数组对象
    let splitText
    if (Array.isArray(text)) {
      splitText = text
    } else {
      splitText = text.toString().trim().split(',')
    }
    for (const txt of splitText) {
      let dictText = txt
      for (const dictItem of dictOptions) {
        if (txt.toString() === dictItem.value.toString()) {
          dictText = (dictItem.text || dictItem.title || dictItem.label)
          break
        }
      }
      result.push(dictText)
    }
    return result.join(',')
  }
  return text
  // --update-end----author:sunjianlei---date:20200323------for: 字典翻译 text 允许逗号分隔 ---
}

/**
  * 字典值替换文本通用方法(多选)
  * @param dictOptions  字典数组
  * @param text  字典值
  * @return String
  */
export function filterMultiDictText (dictOptions, text) {
  // js “!text” 认为0为空，所以做提前处理
  if (text === 0 || text === '0') {
    if (dictOptions) {
      for (const dictItem of dictOptions) {
        if (text === dictItem.value) {
          return dictItem.text
        }
      }
    }
  }

  if (!text || text === 'null' || !dictOptions || dictOptions.length === 0) {
    return ''
  }
  let re = ''
  text = text.toString()
  const arr = text.split(',')
  dictOptions.forEach(function (option) {
    if (option) {
      for (let i = 0; i < arr.length; i++) {
        if (arr[i] === option.value) {
          re += option.text + ','
          break
        }
      }
    }
  })
  if (re === '') {
    return text
  }
  return re.substring(0, re.length - 1)
}

// 字典标签专用（通过code获取字典数组）
const ajaxGetDictItems = (code, params) => getAction(`/sys/dict/getDictItems/${code}`, params)

// 从缓存中获取字典配置
function getDictItemsFromCache (dictCode) {
  if (Vue.ls.get('UI_CACHE_DB_DICT_DATA') && Vue.ls.get('UI_CACHE_DB_DICT_DATA')[dictCode]) {
    const dictItems = Vue.ls.get('UI_CACHE_DB_DICT_DATA')[dictCode]
    return dictItems
  }
}

/**
  * 翻译字段值对应的文本
  * @param children
  * @returns string
  */
export function filterDictTextByCache (dictCode, key) {
  if (key == null || key.length === 0) {
    return
  }
  if (!dictCode) {
    return '字典Code不能为空!'
  }
  // 优先从缓存中读取字典配置
  if (getDictItemsFromCache(dictCode)) {
    const item = getDictItemsFromCache(dictCode).filter(t => t.value === key)
    if (item && item.length > 0) {
      return item[0].text
    }
  }
}

/** 通过code获取字典数组 */
export async function getDictItems (dictCode, params) {
  // 优先从缓存中读取字典配置
  if (getDictItemsFromCache(dictCode)) {
    const desformDictItems = getDictItemsFromCache(dictCode).map(item => ({ ...item, label: item.text }))
    return desformDictItems
  }

  // 缓存中没有，就请求后台
  return await ajaxGetDictItems(dictCode, params).then(({ success, result }) => {
    if (success) {
      const res = result.map(item => ({ ...item, label: item.text }))
      console.log('------- 从DB中获取到了字典-------dictCode : ', dictCode, res)
      return Promise.resolve(res)
    } else {
      console.error('getDictItems error: : ', result)
      return Promise.resolve([])
    }
  }).catch((res) => {
    console.error('getDictItems error: ', res)
    return Promise.resolve([])
  })
}
